/*
   Copyright (c) 2011 Mizar Tools Contributors (mizartools.org)

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
/*  Contributors :
 *	2011-03-26 Marco Riccardi - initial implementation
 *  2011-09-14 Marco Riccardi - changed Property -> AbstractProperty
 *
 */
package org.mizartools.system.xml;

import org.mizartools.system.INode;

public class ToStringVisitor extends Visitor {

	private StringBuilder stringBuilder = new StringBuilder("");
	private boolean isEmpty = true;
	private boolean isFirst = true;
	
	private boolean visit(INode node) {
		String name = "";
		try {java.lang.reflect.Field field = node.getClass().getField("NAME");
			name = (String) field.get(node);
		} 
		catch (SecurityException e) {} 
		catch (NoSuchFieldException e) {} 
		catch (IllegalArgumentException e) {} 
		catch (IllegalAccessException e) {} 
		if (isFirst) {
			stringBuilder.append(name);
			isFirst = false;
			return true;
		} else {
			isEmpty = false;
			stringBuilder.append(" <");
			stringBuilder.append(name);
			stringBuilder.append(">");
			return false;
		}
	}

	@Override
	public String toString(){
		stringBuilder.insert(0, "<");
		if (isEmpty) stringBuilder.append("/");
		stringBuilder.append(">");
		return stringBuilder.toString();
	}

	@Override
	public boolean visit(Abstractness abstractness) {
		return visit((INode) abstractness);
	}

	@Override
	public void endVisit(Abstractness abstractness) {}

	@Override
	public boolean visit(Adjective adjective) {
		return visit((INode) adjective);
	}

	@Override
	public void endVisit(Adjective adjective) {}

	@Override
	public boolean visit(And and) {
		return visit((INode) and);
	}

	@Override
	public void endVisit(And and) {}

	@Override
	public boolean visit(Antisymmetry antisymmetry) {
		return visit((INode) antisymmetry);
	}

	@Override
	public void endVisit(Antisymmetry antisymmetry) {}

	@Override
	public boolean visit(ArgTypes argTypes) {
		return visit((INode) argTypes);
	}

	@Override
	public void endVisit(ArgTypes argTypes) {}

	@Override
	public boolean visit(Article article) {
		return visit((INode) article);
	}

	@Override
	public void endVisit(Article article) {}

	@Override
	public boolean visit(ArticleID articleID) {
		return visit((INode) articleID);
	}

	@Override
	public void endVisit(ArticleID articleID) {}

	@Override
	public boolean visit(Associativity associativity) {
		return visit((INode) associativity);
	}

	@Override
	public void endVisit(Associativity associativity) {}

	@Override
	public boolean visit(Assume assume) {
		return visit((INode) assume);
	}

	@Override
	public void endVisit(Assume assume) {}

	@Override
	public boolean visit(AuxiliaryItem auxiliaryItem) {
		return visit((INode) auxiliaryItem);
	}

	@Override
	public void endVisit(AuxiliaryItem auxiliaryItem) {}

	@Override
	public boolean visit(BlockThesis blockThesis) {
		return visit((INode) blockThesis);
	}

	@Override
	public void endVisit(BlockThesis blockThesis) {}

	@Override
	public boolean visit(By by) {
		return visit((INode) by);
	}

	@Override
	public void endVisit(By by) {}

	@Override
	public boolean visit(ByExplanations byExplanations) {
		return visit((INode) byExplanations);
	}

	@Override
	public void endVisit(ByExplanations byExplanations) {}

	@Override
	public boolean visit(Canceled canceled) {
		return visit((INode) canceled);
	}

	@Override
	public void endVisit(Canceled canceled) {}

	@Override
	public boolean visit(Case case_) {
		return visit((INode) case_);
	}

	@Override
	public void endVisit(Case case_) {}

	@Override
	public boolean visit(CaseBlock caseBlock) {
		return visit((INode) caseBlock);
	}

	@Override
	public void endVisit(CaseBlock caseBlock) {}

	@Override
	public boolean visit(CCluster cCluster) {
		return visit((INode) cCluster);
	}

	@Override
	public void endVisit(CCluster cCluster) {}

	@Override
	public boolean visit(Choice choice) {
		return visit((INode) choice);
	}

	@Override
	public void endVisit(Choice choice) {}

	@Override
	public boolean visit(Cluster cluster) {
		return visit((INode) cluster);
	}

	@Override
	public void endVisit(Cluster cluster) {}

	@Override
	public boolean visit(Coherence coherence) {
		return visit((INode) coherence);
	}

	@Override
	public void endVisit(Coherence coherence) {}

	@Override
	public boolean visit(Commutativity commutativity) {
		return visit((INode) commutativity);
	}

	@Override
	public void endVisit(Commutativity commutativity) {}

	@Override
	public boolean visit(Compatibility compatibility) {
		return visit((INode) compatibility);
	}

	@Override
	public void endVisit(Compatibility compatibility) {}

	@Override
	public boolean visit(ComplexNr complexNr) {
		return visit((INode) complexNr);
	}

	@Override
	public void endVisit(ComplexNr complexNr) {}

	@Override
	public boolean visit(Conclusion conclusion) {
		return visit((INode) conclusion);
	}

	@Override
	public void endVisit(Conclusion conclusion) {}

	@Override
	public boolean visit(Connectedness connectedness) {
		return visit((INode) connectedness);
	}

	@Override
	public void endVisit(Connectedness connectedness) {}

	@Override
	public boolean visit(Consider consider) {
		return visit((INode) consider);
	}

	@Override
	public void endVisit(Consider consider) {}

	@Override
	public boolean visit(Consistency consistency) {
		return visit((INode) consistency);
	}

	@Override
	public void endVisit(Consistency consistency) {}

	@Override
	public boolean visit(Const const_) {
		return visit((INode) const_);
	}

	@Override
	public void endVisit(Const const_) {}

	@Override
	public boolean visit(ConstrCount constrCount) {
		return visit((INode) constrCount);
	}

	@Override
	public void endVisit(ConstrCount constrCount) {}

	@Override
	public boolean visit(ConstrCounts constrCounts) {
		return visit((INode) constrCounts);
	}

	@Override
	public void endVisit(ConstrCounts constrCounts) {}

	@Override
	public boolean visit(ConstrDef constrDef) {
		return visit((INode) constrDef);
	}

	@Override
	public void endVisit(ConstrDef constrDef) {}

	@Override
	public boolean visit(Constructor constructor) {
		return visit((INode) constructor);
	}

	@Override
	public void endVisit(Constructor constructor) {}

	@Override
	public boolean visit(Constructors constructors) {
		return visit((INode) constructors);
	}

	@Override
	public void endVisit(Constructors constructors) {}

	@Override
	public boolean visit(Correctness correctness) {
		return visit((INode) correctness);
	}

	@Override
	public void endVisit(Correctness correctness) {}

	@Override
	public boolean visit(CorrectnessCondition correctnessCondition) {
		return visit((INode) correctnessCondition);
	}

	@Override
	public void endVisit(CorrectnessCondition correctnessCondition) {}

	@Override
	public boolean visit(DefFunc defFunc) {
		return visit((INode) defFunc);
	}

	@Override
	public void endVisit(DefFunc defFunc) {}

	@Override
	public boolean visit(Definiens definiens) {
		return visit((INode) definiens);
	}

	@Override
	public void endVisit(Definiens definiens) {}

	@Override
	public boolean visit(Definientia definientia) {
		return visit((INode) definientia);
	}

	@Override
	public void endVisit(Definientia definientia) {}

	@Override
	public boolean visit(Definition definition) {
		return visit((INode) definition);
	}

	@Override
	public void endVisit(Definition definition) {}

	@Override
	public boolean visit(DefinitionBlock definitionBlock) {
		return visit((INode) definitionBlock);
	}

	@Override
	public void endVisit(DefinitionBlock definitionBlock) {}

	@Override
	public boolean visit(DefMeaning defMeaning) {
		return visit((INode) defMeaning);
	}

	@Override
	public void endVisit(DefMeaning defMeaning) {}

	@Override
	public boolean visit(DefPred defPred) {
		return visit((INode) defPred);
	}

	@Override
	public void endVisit(DefPred defPred) {}

	@Override
	public boolean visit(DefTheorem defTheorem) {
		return visit((INode) defTheorem);
	}

	@Override
	public void endVisit(DefTheorem defTheorem) {}

	@Override
	public boolean visit(Directive directive) {
		return visit((INode) directive);
	}

	@Override
	public void endVisit(Directive directive) {}

	@Override
	public boolean visit(EndPosition endPosition) {
		return visit((INode) endPosition);
	}

	@Override
	public void endVisit(EndPosition endPosition) {}

	@Override
	public boolean visit(Environ environ) {
		return visit((INode) environ);
	}

	@Override
	public void endVisit(Environ environ) {}

	@Override
	public boolean visit(EqArgs eqArgs) {
		return visit((INode) eqArgs);
	}

	@Override
	public void endVisit(EqArgs eqArgs) {}

	@Override
	public boolean visit(ErrorCluster errorCluster) {
		return visit((INode) errorCluster);
	}

	@Override
	public void endVisit(ErrorCluster errorCluster) {}

	@Override
	public boolean visit(ErrorFrm errorFrm) {
		return visit((INode) errorFrm);
	}

	@Override
	public void endVisit(ErrorFrm errorFrm) {}

	@Override
	public boolean visit(ErrorIdentify errorIdentify) {
		return visit((INode) errorIdentify);
	}

	@Override
	public void endVisit(ErrorIdentify errorIdentify) {}

	@Override
	public boolean visit(ErrorInf errorInf) {
		return visit((INode) errorInf);
	}

	@Override
	public void endVisit(ErrorInf errorInf) {}

	@Override
	public boolean visit(ErrorTrm errorTrm) {
		return visit((INode) errorTrm);
	}

	@Override
	public void endVisit(ErrorTrm errorTrm) {}

	@Override
	public boolean visit(Essentials essentials) {
		return visit((INode) essentials);
	}

	@Override
	public void endVisit(Essentials essentials) {}

	@Override
	public boolean visit(Existence existence) {
		return visit((INode) existence);
	}

	@Override
	public void endVisit(Existence existence) {}

	@Override
	public boolean visit(Expansion expansion) {
		return visit((INode) expansion);
	}

	@Override
	public void endVisit(Expansion expansion) {}

	@Override
	public boolean visit(FCluster fCluster) {
		return visit((INode) fCluster);
	}

	@Override
	public void endVisit(FCluster fCluster) {}

	@Override
	public boolean visit(Field field) {
		return visit((INode) field);
	}

	@Override
	public void endVisit(Field field) {}

	@Override
	public boolean visit(Fields fields) {
		return visit((INode) fields);
	}

	@Override
	public void endVisit(Fields fields) {}

	@Override
	public boolean visit(For for_) {
		return visit((INode) for_);
	}

	@Override
	public void endVisit(For for_) {}

	@Override
	public boolean visit(Format format) {
		return visit((INode) format);
	}

	@Override
	public void endVisit(Format format) {}

	@Override
	public boolean visit(Formats formats) {
		return visit((INode) formats);
	}

	@Override
	public void endVisit(Formats formats) {}

	@Override
	public boolean visit(Formula formula) {
		return visit((INode) formula);
	}

	@Override
	public void endVisit(Formula formula) {}

	@Override
	public boolean visit(Fraenkel fraenkel) {
		return visit((INode) fraenkel);
	}

	@Override
	public void endVisit(Fraenkel fraenkel) {}

	@Override
	public boolean visit(FreeVar freeVar) {
		return visit((INode) freeVar);
	}

	@Override
	public void endVisit(FreeVar freeVar) {}

	@Override
	public boolean visit(From from) {
		return visit((INode) from);
	}

	@Override
	public void endVisit(From from) {}

	@Override
	public boolean visit(FromExplanations fromExplanations) {
		return visit((INode) fromExplanations);
	}

	@Override
	public void endVisit(FromExplanations fromExplanations) {}

	@Override
	public boolean visit(Func func) {
		return visit((INode) func);
	}

	@Override
	public void endVisit(Func func) {}

	@Override
	public boolean visit(FuncInstance funcInstance) {
		return visit((INode) funcInstance);
	}

	@Override
	public void endVisit(FuncInstance funcInstance) {}

	@Override
	public boolean visit(GeneralPolynomial generalPolynomial) {
		return visit((INode) generalPolynomial);
	}

	@Override
	public void endVisit(GeneralPolynomial generalPolynomial) {}

	@Override
	public boolean visit(Given given) {
		return visit((INode) given);
	}

	@Override
	public void endVisit(Given given) {}

	@Override
	public boolean visit(Idempotence idempotence) {
		return visit((INode) idempotence);
	}

	@Override
	public void endVisit(Idempotence idempotence) {}

	@Override
	public boolean visit(Ident ident) {
		return visit((INode) ident);
	}

	@Override
	public void endVisit(Ident ident) {}

	@Override
	public boolean visit(Identify identify) {
		return visit((INode) identify);
	}

	@Override
	public void endVisit(Identify identify) {}

	@Override
	public boolean visit(IdentifyRegistration identifyRegistration) {
		return visit((INode) identifyRegistration);
	}

	@Override
	public void endVisit(IdentifyRegistration identifyRegistration) {}

	@Override
	public boolean visit(IdentifyRegistrations identifyRegistrations) {
		return visit((INode) identifyRegistrations);
	}

	@Override
	public void endVisit(IdentifyRegistrations identifyRegistrations) {}

	@Override
	public boolean visit(IdentifyWithExp identifyWithExp) {
		return visit((INode) identifyWithExp);
	}

	@Override
	public void endVisit(IdentifyWithExp identifyWithExp) {}

	@Override
	public boolean visit(InfConst infConst) {
		return visit((INode) infConst);
	}

	@Override
	public void endVisit(InfConst infConst) {}

	@Override
	public boolean visit(Inference inference) {
		return visit((INode) inference);
	}

	@Override
	public void endVisit(Inference inference) {}

	@Override
	public boolean visit(Int int_) {
		return visit((INode) int_);
	}

	@Override
	public void endVisit(Int int_) {}

	@Override
	public boolean visit(Involutiveness involutiveness) {
		return visit((INode) involutiveness);
	}

	@Override
	public void endVisit(Involutiveness involutiveness) {}

	@Override
	public boolean visit(Irreflexivity irreflexivity) {
		return visit((INode) irreflexivity);
	}

	@Override
	public void endVisit(Irreflexivity irreflexivity) {}

	@Override
	public boolean visit(Is is) {
		return visit((INode) is);
	}

	@Override
	public void endVisit(Is is) {}

	@Override
	public boolean visit(It it) {
		return visit((INode) it);
	}

	@Override
	public void endVisit(It it) {}

	@Override
	public boolean visit(IterEquality iterEquality) {
		return visit((INode) iterEquality);
	}

	@Override
	public void endVisit(IterEquality iterEquality) {}

	@Override
	public boolean visit(IterStep iterStep) {
		return visit((INode) iterStep);
	}

	@Override
	public void endVisit(IterStep iterStep) {}

	@Override
	public boolean visit(Justification justification) {
		return visit((INode) justification);
	}

	@Override
	public void endVisit(Justification justification) {}

	@Override
	public boolean visit(JustifiedProperty justifiedProperty) {
		return visit((INode) justifiedProperty);
	}

	@Override
	public void endVisit(JustifiedProperty justifiedProperty) {}

	@Override
	public boolean visit(JustifiedProposition justifiedProposition) {
		return visit((INode) justifiedProposition);
	}

	@Override
	public void endVisit(JustifiedProposition justifiedProposition) {}

	@Override
	public boolean visit(JustifiedTheorem justifiedTheorem) {
		return visit((INode) justifiedTheorem);
	}

	@Override
	public void endVisit(JustifiedTheorem justifiedTheorem) {}

	@Override
	public boolean visit(LambdaVar lambdaVar) {
		return visit((INode) lambdaVar);
	}

	@Override
	public void endVisit(LambdaVar lambdaVar) {}

	@Override
	public boolean visit(Let let) {
		return visit((INode) let);
	}

	@Override
	public void endVisit(Let let) {}

	@Override
	public boolean visit(LocusVar locusVar) {
		return visit((INode) locusVar);
	}

	@Override
	public void endVisit(LocusVar locusVar) {}

	@Override
	public boolean visit(Monomial monomial) {
		return visit((INode) monomial);
	}

	@Override
	public void endVisit(Monomial monomial) {}

	@Override
	public boolean visit(Not not) {
		return visit((INode) not);
	}

	@Override
	public void endVisit(Not not) {}

	@Override
	public boolean visit(NotationBlock notationBlock) {
		return visit((INode) notationBlock);
	}

	@Override
	public void endVisit(NotationBlock notationBlock) {}

	@Override
	public boolean visit(Notations notations) {
		return visit((INode) notations);
	}

	@Override
	public void endVisit(Notations notations) {}

	@Override
	public boolean visit(Now now) {
		return visit((INode) now);
	}

	@Override
	public void endVisit(Now now) {}

	@Override
	public boolean visit(Num num) {
		return visit((INode) num);
	}

	@Override
	public void endVisit(Num num) {}

	@Override
	public boolean visit(Number number) {
		return visit((INode) number);
	}

	@Override
	public void endVisit(Number number) {}

	@Override
	public boolean visit(Pair pair) {
		return visit((INode) pair);
	}

	@Override
	public void endVisit(Pair pair) {}

	@Override
	public boolean visit(PartialDef partialDef) {
		return visit((INode) partialDef);
	}

	@Override
	public void endVisit(PartialDef partialDef) {}

	@Override
	public boolean visit(Pattern pattern) {
		return visit((INode) pattern);
	}

	@Override
	public void endVisit(Pattern pattern) {}

	@Override
	public boolean visit(PerCases perCases) {
		return visit((INode) perCases);
	}

	@Override
	public void endVisit(PerCases perCases) {}

	@Override
	public boolean visit(PerCasesReasoning perCasesReasoning) {
		return visit((INode) perCasesReasoning);
	}

	@Override
	public void endVisit(PerCasesReasoning perCasesReasoning) {}

	@Override
	public boolean visit(PolyEval polyEval) {
		return visit((INode) polyEval);
	}

	@Override
	public void endVisit(PolyEval polyEval) {}

	@Override
	public boolean visit(Polynomial polynomial) {
		return visit((INode) polynomial);
	}

	@Override
	public void endVisit(Polynomial polynomial) {}

	@Override
	public boolean visit(PoweredVar poweredVar) {
		return visit((INode) poweredVar);
	}

	@Override
	public void endVisit(PoweredVar poweredVar) {}

	@Override
	public boolean visit(Pred pred) {
		return visit((INode) pred);
	}

	@Override
	public void endVisit(Pred pred) {}

	@Override
	public boolean visit(PredInstance predInstance) {
		return visit((INode) predInstance);
	}

	@Override
	public void endVisit(PredInstance predInstance) {}

	@Override
	public boolean visit(Priority priority) {
		return visit((INode) priority);
	}

	@Override
	public void endVisit(Priority priority) {}

	@Override
	public boolean visit(PrivFunc privFunc) {
		return visit((INode) privFunc);
	}

	@Override
	public void endVisit(PrivFunc privFunc) {}

	@Override
	public boolean visit(PrivPred privPred) {
		return visit((INode) privPred);
	}

	@Override
	public void endVisit(PrivPred privPred) {}

	@Override
	public boolean visit(Projectivity projectivity) {
		return visit((INode) projectivity);
	}

	@Override
	public void endVisit(Projectivity projectivity) {}

	@Override
	public boolean visit(Proof proof) {
		return visit((INode) proof);
	}

	@Override
	public void endVisit(Proof proof) {}

	@Override
	public boolean visit(Properties properties) {
		return visit((INode) properties);
	}

	@Override
	public void endVisit(Properties properties) {}

	@Override
	public boolean visit(AbstractProperty property) {
		return visit((INode) property);
	}

	@Override
	public void endVisit(AbstractProperty property) {}

	@Override
	public boolean visit(Proposition proposition) {
		return visit((INode) proposition);
	}

	@Override
	public void endVisit(Proposition proposition) {}

	@Override
	public boolean visit(QuaTrm quaTrm) {
		return visit((INode) quaTrm);
	}

	@Override
	public void endVisit(QuaTrm quaTrm) {}

	@Override
	public boolean visit(RationalNr rationalNr) {
		return visit((INode) rationalNr);
	}

	@Override
	public void endVisit(RationalNr rationalNr) {}

	@Override
	public boolean visit(RCluster rCluster) {
		return visit((INode) rCluster);
	}

	@Override
	public void endVisit(RCluster rCluster) {}

	@Override
	public boolean visit(Reasoning reasoning) {
		return visit((INode) reasoning);
	}

	@Override
	public void endVisit(Reasoning reasoning) {}

	@Override
	public boolean visit(ReasoningItem reasoningItem) {
		return visit((INode) reasoningItem);
	}

	@Override
	public void endVisit(ReasoningItem reasoningItem) {}

	@Override
	public boolean visit(Reconsider reconsider) {
		return visit((INode) reconsider);
	}

	@Override
	public void endVisit(Reconsider reconsider) {}

	@Override
	public boolean visit(Ref ref) {
		return visit((INode) ref);
	}

	@Override
	public void endVisit(Ref ref) {}

	@Override
	public boolean visit(Reflexivity reflexivity) {
		return visit((INode) reflexivity);
	}

	@Override
	public void endVisit(Reflexivity reflexivity) {}

	@Override
	public boolean visit(Registration registration) {
		return visit((INode) registration);
	}

	@Override
	public void endVisit(Registration registration) {}

	@Override
	public boolean visit(RegistrationBlock registrationBlock) {
		return visit((INode) registrationBlock);
	}

	@Override
	public void endVisit(RegistrationBlock registrationBlock) {}

	@Override
	public boolean visit(Registrations registrations) {
		return visit((INode) registrations);
	}

	@Override
	public void endVisit(Registrations registrations) {}

	@Override
	public boolean visit(Requirement requirement) {
		return visit((INode) requirement);
	}

	@Override
	public void endVisit(Requirement requirement) {}

	@Override
	public boolean visit(Requirements requirements) {
		return visit((INode) requirements);
	}

	@Override
	public void endVisit(Requirements requirements) {}

	@Override
	public boolean visit(Reservation reservation) {
		return visit((INode) reservation);
	}

	@Override
	public void endVisit(Reservation reservation) {}

	@Override
	public boolean visit(Scheme scheme) {
		return visit((INode) scheme);
	}

	@Override
	public void endVisit(Scheme scheme) {}

	@Override
	public boolean visit(SchemeBlock schemeBlock) {
		return visit((INode) schemeBlock);
	}

	@Override
	public void endVisit(SchemeBlock schemeBlock) {}

	@Override
	public boolean visit(SchemeDecl schemeDecl) {
		return visit((INode) schemeDecl);
	}

	@Override
	public void endVisit(SchemeDecl schemeDecl) {}

	@Override
	public boolean visit(SchemeFuncDecl schemeFuncDecl) {
		return visit((INode) schemeFuncDecl);
	}

	@Override
	public void endVisit(SchemeFuncDecl schemeFuncDecl) {}

	@Override
	public boolean visit(SchemeInstantiation schemeInstantiation) {
		return visit((INode) schemeInstantiation);
	}

	@Override
	public void endVisit(SchemeInstantiation schemeInstantiation) {}

	@Override
	public boolean visit(SchemePredDecl schemePredDecl) {
		return visit((INode) schemePredDecl);
	}

	@Override
	public void endVisit(SchemePredDecl schemePredDecl) {}

	@Override
	public boolean visit(SchemePremises schemePremises) {
		return visit((INode) schemePremises);
	}

	@Override
	public void endVisit(SchemePremises schemePremises) {}

	@Override
	public boolean visit(Schemes schemes) {
		return visit((INode) schemes);
	}

	@Override
	public void endVisit(Schemes schemes) {}

	@Override
	public boolean visit(Section section) {
		return visit((INode) section);
	}

	@Override
	public void endVisit(Section section) {}

	@Override
	public boolean visit(Set set) {
		return visit((INode) set);
	}

	@Override
	public void endVisit(Set set) {}

	@Override
	public boolean visit(Signature signature) {
		return visit((INode) signature);
	}

	@Override
	public void endVisit(Signature signature) {}

	@Override
	public boolean visit(SignatureWithCounts signatureWithCounts) {
		return visit((INode) signatureWithCounts);
	}

	@Override
	public void endVisit(SignatureWithCounts signatureWithCounts) {}

	@Override
	public boolean visit(SkeletonItem skeletonItem) {
		return visit((INode) skeletonItem);
	}

	@Override
	public void endVisit(SkeletonItem skeletonItem) {}

	@Override
	public boolean visit(SkippedProof skippedProof) {
		return visit((INode) skippedProof);
	}

	@Override
	public void endVisit(SkippedProof skippedProof) {}

	@Override
	public boolean visit(StructLoci structLoci) {
		return visit((INode) structLoci);
	}

	@Override
	public void endVisit(StructLoci structLoci) {}

	@Override
	public boolean visit(Suppose suppose) {
		return visit((INode) suppose);
	}

	@Override
	public void endVisit(Suppose suppose) {}

	@Override
	public boolean visit(SupposeBlock supposeBlock) {
		return visit((INode) supposeBlock);
	}

	@Override
	public void endVisit(SupposeBlock supposeBlock) {}

	@Override
	public boolean visit(Symbol symbol) {
		return visit((INode) symbol);
	}

	@Override
	public void endVisit(Symbol symbol) {}

	@Override
	public boolean visit(SymbolCount symbolCount) {
		return visit((INode) symbolCount);
	}

	@Override
	public void endVisit(SymbolCount symbolCount) {}

	@Override
	public boolean visit(Symbols symbols) {
		return visit((INode) symbols);
	}

	@Override
	public void endVisit(Symbols symbols) {}

	@Override
	public boolean visit(Symmetry symmetry) {
		return visit((INode) symmetry);
	}

	@Override
	public void endVisit(Symmetry symmetry) {}

	@Override
	public boolean visit(Take take) {
		return visit((INode) take);
	}

	@Override
	public void endVisit(Take take) {}

	@Override
	public boolean visit(TakeAsVar takeAsVar) {
		return visit((INode) takeAsVar);
	}

	@Override
	public void endVisit(TakeAsVar takeAsVar) {}

	@Override
	public boolean visit(Term term) {
		return visit((INode) term);
	}

	@Override
	public void endVisit(Term term) {}

	@Override
	public boolean visit(Theorem theorem) {
		return visit((INode) theorem);
	}

	@Override
	public void endVisit(Theorem theorem) {}

	@Override
	public boolean visit(Theorems theorems) {
		return visit((INode) theorems);
	}

	@Override
	public void endVisit(Theorems theorems) {}

	@Override
	public boolean visit(Thesis thesis) {
		return visit((INode) thesis);
	}

	@Override
	public void endVisit(Thesis thesis) {}

	@Override
	public boolean visit(ThesisExpansions thesisExpansions) {
		return visit((INode) thesisExpansions);
	}

	@Override
	public void endVisit(ThesisExpansions thesisExpansions) {}

	@Override
	public boolean visit(ToStringVisitor toStringVisitor) {
		return visit((INode) toStringVisitor);
	}

	@Override
	public void endVisit(ToStringVisitor toStringVisitor) {}

	@Override
	public boolean visit(Transitivity transitivity) {
		return visit((INode) transitivity);
	}

	@Override
	public void endVisit(Transitivity transitivity) {}

	@Override
	public boolean visit(Typ typ) {
		return visit((INode) typ);
	}

	@Override
	public void endVisit(Typ typ) {}

	@Override
	public boolean visit(UnexpectedProp unexpectedProp) {
		return visit((INode) unexpectedProp);
	}

	@Override
	public void endVisit(UnexpectedProp unexpectedProp) {}

	@Override
	public boolean visit(Uniqueness uniqueness) {
		return visit((INode) uniqueness);
	}

	@Override
	public void endVisit(Uniqueness uniqueness) {}

	@Override
	public boolean visit(UnknownCorrCond unknownCorrCond) {
		return visit((INode) unknownCorrCond);
	}

	@Override
	public void endVisit(UnknownCorrCond unknownCorrCond) {}

	@Override
	public boolean visit(Var var) {
		return visit((INode) var);
	}

	@Override
	public void endVisit(Var var) {}

	@Override
	public boolean visit(Verum verum) {
		return visit((INode) verum);
	}

	@Override
	public void endVisit(Verum verum) {}

	@Override
	public boolean visit(Visible visible) {
		return visit((INode) visible);
	}

	@Override
	public void endVisit(Visible visible) {}

	@Override
	public boolean visit(Vocabularies vocabularies) {
		return visit((INode) vocabularies);
	}

	@Override
	public void endVisit(Vocabularies vocabularies) {}

	@Override
	public boolean visit(Vocabulary vocabulary) {
		return visit((INode) vocabulary);
	}

	@Override
	public void endVisit(Vocabulary vocabulary) {}
	
}
